<html>
<head><meta charset="utf-8"><title>rust calling convention and LLVM · t-compiler · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/index.html">t-compiler</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html">rust calling convention and LLVM</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="135611607"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135611607" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135611607">(Oct 11 2018 at 14:26)</a>:</h4>
<p>How does the concept of the <code>"Rust"</code> calling convention make its way into LLVM? LLVM has built-in concepts for other types of calling conventions / ABIs like <code>"C"</code> or <code>"stdcall"</code>, but not one for <code>"Rust"</code>.</p>



<a name="135611699"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135611699" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135611699">(Oct 11 2018 at 14:27)</a>:</h4>
<p>its just "unspecified", which in LLVM case can translate into any of <em>its</em> calling conventions</p>



<a name="135611744"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135611744" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135611744">(Oct 11 2018 at 14:28)</a>:</h4>
<p>but what also matters is types of arguments</p>



<a name="135611756"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135611756" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135611756">(Oct 11 2018 at 14:28)</a>:</h4>
<p>which in <code>Rust</code> cc are just unspecified and chosen fairly arbitrarily</p>



<a name="135611796"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135611796" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135611796">(Oct 11 2018 at 14:29)</a>:</h4>
<p>hm, <a href="https://github.com/rust-lang/rust/blob/fddcd316af98583ebebfc40f6a25bec3f4e5fccc/src/librustc_codegen_llvm/abi.rs#L338-L340" target="_blank" title="https://github.com/rust-lang/rust/blob/fddcd316af98583ebebfc40f6a25bec3f4e5fccc/src/librustc_codegen_llvm/abi.rs#L338-L340">https://github.com/rust-lang/rust/blob/fddcd316af98583ebebfc40f6a25bec3f4e5fccc/src/librustc_codegen_llvm/abi.rs#L338-L340</a> seems to indicate it's "C" to LLVM?</p>



<a name="135611809"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135611809" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> simulacrum <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135611809">(Oct 11 2018 at 14:29)</a>:</h4>
<p>(but maybe that's the wrong place to look)</p>



<a name="135611810"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135611810" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135611810">(Oct 11 2018 at 14:29)</a>:</h4>
<blockquote>
<p>its just "unspecified", which in LLVM case can translate into any of <em>its</em> calling conventions</p>
</blockquote>
<p>Well let me correct myself. If the calling convention in LLVM is unspecified, it is usually just the prevailing calling convention for the platform.</p>



<a name="135611841"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135611841" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135611841">(Oct 11 2018 at 14:29)</a>:</h4>
<p>but like I said, how arguments are passed also matters. To get actual "C", the arguments should be passed around in a very specific manner. This does not apply to the rust calling convention</p>



<a name="135611884"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135611884" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135611884">(Oct 11 2018 at 14:30)</a>:</h4>
<p>which is how it becomes unspecified and arbitrary.</p>



<a name="135612589"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135612589" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135612589">(Oct 11 2018 at 14:38)</a>:</h4>
<p>This is in the context of the AVR port, where people are working on the actual LLVM side of it as well, FWIW.</p>



<a name="135612637"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135612637" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135612637">(Oct 11 2018 at 14:39)</a>:</h4>
<p>Well yeah, then whatever AVR does with "unspecified" calling convention on its side is correct.</p>



<a name="135612650"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135612650" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135612650">(Oct 11 2018 at 14:39)</a>:</h4>
<p>which can be compatible with C (and will most likely be) for all its worth</p>



<a name="135612657"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135612657" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135612657">(Oct 11 2018 at 14:39)</a>:</h4>
<p>So it seems likely that <code>"Rust"</code> will set up some concoction of arguments and hand that off to LLVM, which is most likely going to try to align with what GCC outputs</p>



<a name="135612733"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135612733" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135612733">(Oct 11 2018 at 14:40)</a>:</h4>
<p>possibly. It is however a case that Rust often gives LLVM arguments in a manner that C would never do</p>



<a name="135612762"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135612762" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135612762">(Oct 11 2018 at 14:41)</a>:</h4>
<p>passing large arrays by value is one example of such case.</p>



<a name="135612771"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135612771" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135612771">(Oct 11 2018 at 14:41)</a>:</h4>
<p>Is there any concrete thing (that wouldn't take too much of your time to explain) you could show as an example of how the arguments...</p>



<a name="135612910"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135612910" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135612910">(Oct 11 2018 at 14:42)</a>:</h4>
<p>oh, hmm, apparently we now pass larger arrays by reference…</p>



<a name="135612948"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135612948" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135612948">(Oct 11 2018 at 14:43)</a>:</h4>
<p><span class="user-mention" data-user-id="116155">@Jake Goulding</span> in that case a good example is probably 2-element tuples and fat pointers</p>



<a name="135612966"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135612966" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135612966">(Oct 11 2018 at 14:43)</a>:</h4>
<p>which Rust will split into two separate arguments in some cases, despite it really being just one</p>



<a name="135612987"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135612987" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135612987">(Oct 11 2018 at 14:43)</a>:</h4>
<p>that’s probably the best example to give as it is most commonplace too.</p>



<a name="135613089"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135613089" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135613089">(Oct 11 2018 at 14:44)</a>:</h4>
<p>then there’s also i128, which C on <em>avr</em> will definitely not support, and thus won’t ever pass as an argument <span class="emoji emoji-1f642" title="slight smile">:slight_smile:</span></p>



<a name="135613142"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135613142" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135613142">(Oct 11 2018 at 14:45)</a>:</h4>
<p>(it usually ends up becoming a literal <code>i128</code> in LLVM)</p>



<a name="135613161"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135613161" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135613161">(Oct 11 2018 at 14:45)</a>:</h4>
<p>(and very likely a pointer with some sort of platform-specific ABI in C)</p>



<a name="135613172"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135613172" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135613172">(Oct 11 2018 at 14:45)</a>:</h4>
<p>Whereas Rust-on-AVR will support <code>i128</code> (we will just generate some code that uses up all of your registers, most likely)</p>



<a name="135613270"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135613270" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135613270">(Oct 11 2018 at 14:46)</a>:</h4>
<blockquote>
<p>we now pass larger arrays by reference</p>
</blockquote>
<p>And that's part of what makes it the <code>"Rust"</code> ABI as well, the fact that these things can change without warning.</p>



<a name="135613394"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135613394" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135613394">(Oct 11 2018 at 14:48)</a>:</h4>
<p>definitely.</p>



<a name="135613463"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135613463" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135613463">(Oct 11 2018 at 14:49)</a>:</h4>
<div class="codehilite"><pre><span></span><span class="k">pub</span><span class="w"> </span><span class="k">extern</span><span class="w"> </span><span class="s">&quot;Rust&quot;</span><span class="w"> </span><span class="k">fn</span> <span class="nf">foo</span><span class="p">(</span><span class="n">_</span>: <span class="p">(</span><span class="kt">i32</span><span class="p">,</span><span class="w"> </span><span class="kt">i32</span><span class="p">))</span><span class="w"> </span><span class="p">{}</span><span class="w"></span>
<span class="c1">// &quot;Rust&quot; =&gt; define void @_ZN10playground3foo17hb3200a9d2844f1a1E(i32, i32)</span>
<span class="c1">// &quot;C&quot;    =&gt; define void @_ZN10playground3foo17h740a1913e9510d11E(i64)</span>
</pre></div>


<p>Is that what you were talking about? (I'd bet that using a tuple in <code>extern "C"</code> is invalid, but it demonstrates it)</p>



<a name="135613724"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135613724" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135613724">(Oct 11 2018 at 14:52)</a>:</h4>
<p>Yes, this is one of the scenarios. It will end up using different number of registers etc.</p>



<a name="135613983"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135613983" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135613983">(Oct 11 2018 at 14:56)</a>:</h4>
<p>So the C frontend would see the equivalent of <code>void foo(i128 bar)</code> and emit LLVM like <code>define void foo(* i128)</code>. </p>
<p>Rust would see <code> fn foo(bar: i128)</code> and emit <code>define void foo( i128)</code>, but if it saw <code>extern "C" fn foo(bar: i128)</code>, it would emit <code>define void foo(* i128)</code>, as C did.</p>



<a name="135614003"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135614003" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135614003">(Oct 11 2018 at 14:56)</a>:</h4>
<p>Is this the difference between a calling convention and an ABI?</p>



<a name="135614057"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135614057" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135614057">(Oct 11 2018 at 14:57)</a>:</h4>
<p>I guess, yes. It would be more appropriate to call those "convention" annotations on top of LLVM functions as influencing ABI instead</p>



<a name="135614106"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135614106" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135614106">(Oct 11 2018 at 14:58)</a>:</h4>
<p>and then compilers are responsible ensuring that both ABI and the way the arguments are passed match.</p>



<a name="135615197"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/131828-t-compiler/topic/rust%20calling%20convention%20and%20LLVM/near/135615197" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jake Goulding <a href="https://rust-lang.github.io/zulip_archive/stream/131828-t-compiler/topic/rust.20calling.20convention.20and.20LLVM.html#135615197">(Oct 11 2018 at 15:12)</a>:</h4>
<p>Thank you both very much! It's always nice to learn that I was wrong and now I can correct myself going forward.</p>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>